import axios from 'axios'
import { ElMessage } from 'element-plus'
import { useUserStore } from '@/stores/modules/user'
import { useAdminStore } from '@/stores/modules/admin'

// 从cookie中获取指定值的辅助函数
export const getCookieValue = (name) => {  // 添加 export 关键字
  const cookies = document.cookie.split(';')
  for (let cookie of cookies) {
    const [cookieName, value] = cookie.trim().split('=')
    if (cookieName === name) {
      return value
    }
  }
  return null
}

// 创建axios实例
const service = axios.create({
  baseURL: import.meta.env.VITE_API_BASE_URL,
  timeout: 15000,
  withCredentials: true  // 允许跨域请求携带cookie
})

// 是否正在刷新token
let isRefreshing = false
// 重试队列
let retryRequests = []

// 请求拦截器
service.interceptors.request.use(
  async config => {
    // 如果是刷新token的请求，跳过token检查
    if (config.url === '/auth/refresh-token' && config.method === 'post') {
      return config;
    }
    
    // 判断是否是后台API请求
    const isAdminRequest = config.url.startsWith('/admin')
    || config.url.startsWith('/jiang') 
    || config.url.startsWith('/goods/jiang')
    || config.url.startsWith('/order/jiang')
    || config.url.startsWith('/cart/jiang')
    || config.url.startsWith('/shop/jiang')
    || config.url.startsWith('/auth/jiang')
    || config.url.startsWith('/chat/getUserChatHistory')
    if (isAdminRequest) {
      // 后台请求，使用管理员token
      const adminStore = useAdminStore()
      
      // 只有当token存在且即将过期时才刷新
      if (adminStore.accessToken && adminStore.isTokenExpired) {
        await adminStore.refreshToken()
      }
      
      if (adminStore.accessToken) {
        config.headers['Authorization'] = `Bearer ${adminStore.accessToken}`
      }
    } else {
      // 前台请求，使用普通用户token
      const userStore = useUserStore()
      
      // 只有当token存在且即将过期时才刷新
      if (userStore.accessToken && userStore.isTokenExpired) {
        await userStore.refreshToken()
      }
      
      // 从cookie中获取用户id
      const cookies = document.cookie.split(';')
      const idCookie = cookies.find(item => item.trim().startsWith('id='))
      const uid = idCookie ? idCookie.split('=')[1].trim() : null
      if (uid) {
        config.headers['uid'] = uid
      }
      
      // 从Pinia中获取accessToken
      if (userStore.accessToken) {
        config.headers['Authorization'] = `Bearer ${userStore.accessToken}`
      }
    }
    
    return config
  },
  error => {
    console.error('请求错误：', error)
    return Promise.reject(error)
  }
)

// 响应拦截器
service.interceptors.response.use(
  response => {
    const res = response.data
    
    // 如果响应成功
    if (res.code === 200) {
      return res.data
    }
    
    // 如果token过期
    if (res.code === 401) {
      // 判断是否是后台API请求
      const isAdminRequest = response.config.url.startsWith('/jiang')
      
      if (isAdminRequest) {
        // 后台请求，处理管理员token过期
        const adminStore = useAdminStore()
        
        if (!isRefreshing) {
          isRefreshing = true
          
          // 尝试刷新管理员token
          return adminStore.refreshToken()
            .then(() => {
              // 刷新成功，重试队列中的请求
              retryRequests.forEach(cb => cb())
              retryRequests = []
              // 重试当前请求
              return service(response.config)
            })
            .catch(error => {
              // 刷新失败，清空重试队列
              retryRequests = []
              // 跳转到后台登录页
              window.location.href = '/jiang/adminLogin'
              return Promise.reject(error)
            })
            .finally(() => {
              isRefreshing = false
            })
        } else {
          // 如果正在刷新token，将请求加入重试队列
          return new Promise(resolve => {
            retryRequests.push(() => {
              // 使用Pinia中的最新管理员token
              if (adminStore.accessToken) {
                response.config.headers['Authorization'] = `Bearer ${adminStore.accessToken}`
              }
              resolve(service(response.config))
            })
          })
        }
      } else {
        // 前台请求，处理普通用户token过期
        const userStore = useUserStore()
        
        if (!isRefreshing) {
          isRefreshing = true
          
          // 尝试刷新token
          return userStore.refreshToken()
            .then(() => {
              // 刷新成功，重试队列中的请求
              retryRequests.forEach(cb => cb())
              retryRequests = []
              // 重试当前请求
              return service(response.config)
            })
            .catch(error => {
              // 刷新失败，清空重试队列
              retryRequests = []
              // 跳转到登录页
              window.location.href = '/login'
              return Promise.reject(error)
            })
            .finally(() => {
              isRefreshing = false
            })
        } else {
          // 如果正在刷新token，将请求加入重试队列
          return new Promise(resolve => {
            retryRequests.push(() => {
              // 使用Pinia中的最新token
              if (userStore.accessToken) {
                response.config.headers['Authorization'] = `Bearer ${userStore.accessToken}`
              }
              resolve(service(response.config))
            })
          })
        }
      }
    }
    
    // 其他错误
    console.error(res.message || '请求失败')
    return Promise.reject(new Error(res.message || '请求失败'))
  },
  error => {
    console.error('响应错误：', error)
    console.error(error.message || '请求失败')
    return Promise.reject(error)
  }
)

export default service